crates/engine/src/parser/oracle_effect/tests.rs (1)

28634-28709: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Wrapper coverage is partial: only Ref/Offset are exercised.

quantity_expr_reads_source_counters has 8 recursive wrapper arms (DivideRounded, Offset, ClampMin, Multiply, Sum, Max, UpTo, Power, Difference), but this test only drives propagation through Offset. Consider adding a couple more positive cases (e.g. Sum/Difference, which take two sub-expressions and are the likeliest place for a copy-paste slip) to lock in the exhaustive-walk guarantee the doc comment advertises.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/engine/src/parser/oracle_effect/tests.rs` around lines 28634 - 28709,
Add positive test cases in
condition_refs_source_object_source_counter_quantity_check covering additional
quantity_expr_reads_source_counters wrappers, especially binary Sum and
Difference expressions containing a source-scoped CountersOn reference. Keep the
assertions focused on propagation through both operands and preserve the
existing non-source and wrapper coverage.

crates/phase-ai/src/bin/ai_commander.rs-1050-1070 (1)

1050-1070: 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Correct the doc comment: measurement mode is no longer unconditional.

The first paragraph states that EVERY seat runs in measurement mode. build_seat_config now selects the mode from run_context, and RunContext::Interactive keeps the wall-clock deadline. Scope the paragraph to the measurement route so the summary matches the code.

📝 Proposed doc correction

-/// EVERY seat runs in MEASUREMENT mode (`AiConfig::into_measurement`), which
-/// disables the wall-clock search deadline (`AI_SEARCH_TIME_BUDGET_MS`, default
+/// Under `RunContext::Measurement`, every seat runs with
+/// `AiConfig::into_measurement`, which
+/// disables the wall-clock search deadline (`AI_SEARCH_TIME_BUDGET_MS`, default
 /// 1500ms) so search is bounded SOLELY by `max_nodes`/`max_depth`.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/phase-ai/src/bin/ai_commander.rs` around lines 1050 - 1070, Update the
documentation in build_seat_config to scope the measurement-mode behavior to
seats configured through the measurement route, rather than claiming every seat
uses AiConfig::into_measurement. Explicitly preserve that
RunContext::Interactive retains the wall-clock search deadline, while
measurement mode remains bounded by max_nodes/max_depth for reproducibility.

crates/engine/src/game/mana_sources.rs-2388-2394 (1)

2388-2394: 🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Colorless intrinsic land production stays ungated.

mana_type_to_color returns None for a colorless mana type, so is_some_and yields false and blocked stays false. A land whose only mana source is a granted colorless basic land subtype (Wastes class) therefore bypasses intrinsic_land_mana_ability_blocked entirely, which is the same gate-bypass class this change closes for colored subtypes (issue #6469).

Route the colorless case through the same readiness check, or record in the comment that intrinsic_land_mana_ability_definition accepts only a ManaColor and that colorless intrinsic production is intentionally out of scope.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/engine/src/game/mana_sources.rs` around lines 2388 - 2394, Update the
blocked calculation near intrinsic land mana handling so colorless mana types
also go through the appropriate readiness gate instead of being skipped when
mana_type_to_color returns None. Reuse intrinsic_land_mana_ability_blocked where
possible, or explicitly document in the surrounding logic that
intrinsic_land_mana_ability_definition only supports ManaColor and colorless
production is intentionally excluded.

crates/server-core/src/game_action_payload_guard.rs-568-570 (1)

568-570: 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Rejection messages will name the wrong action for ActivateManaSource.

guard_mana_source_selection_payload hardcodes the "TapLandForMana.selection…" prefix in every error string (lines 207, 212, 217, 222). A hostile ActivateManaSource payload is now rejected with a field path that names an action the client did not send. Pass the action label into the helper so the reason matches the rejected variant.

🔧 Proposed fix

-        GameAction::TapLandForMana { selection } | GameAction::ActivateManaSource { selection } => {
-            guard_mana_source_selection_payload(selection)?;
-        }
+        GameAction::TapLandForMana { selection } => {
+            guard_mana_source_selection_payload("TapLandForMana", selection)?;
+        }
+        GameAction::ActivateManaSource { selection } => {
+            guard_mana_source_selection_payload("ActivateManaSource", selection)?;
+        }

Then build each label from the passed action name inside the helper.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/server-core/src/game_action_payload_guard.rs` around lines 568 - 570,
Update guard_mana_source_selection_payload and its call site in the GameAction
match to accept the action label, passing the appropriate label for
TapLandForMana or ActivateManaSource. Build every rejection field path inside
the helper from that label instead of hardcoding “TapLandForMana.selection”, so
each error identifies the actual rejected action.

client/src/components/multiplayer/ConcedeDialog.tsx-58-75 (1)

58-75: 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Raise the button height to meet the 44pt touch target.

px-5 py-2 text-sm produces roughly a 36px tall control. The path instructions require touch targets of at least 44pt. Both changed buttons use this padding.

Add min-h-11 (44px) and center the label.

🛠️ Proposed change

               <button
                 onClick={gameAction.onConfirm}
-                className="rounded-lg bg-red-600 px-5 py-2 text-sm font-semibold text-white transition hover:bg-red-500"
+                className="min-h-11 rounded-lg bg-red-600 px-5 py-2 text-sm font-semibold text-white transition hover:bg-red-500"
               >

Apply the same min-h-11 to the match button at line 71.

As per path instructions: "Touch targets >= 44pt".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@client/src/components/multiplayer/ConcedeDialog.tsx` around lines 58 - 75,
Update both the game and match confirmation buttons in ConcedeDialog to include
min-h-11 and vertically center their labels, preserving their existing styling
and behavior.

Source: Path instructions

client/src/adapter/__tests__/p2pDraftHostBo3.test.ts-437-445 (1)

437-445: 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

This test exercises the !pairing branch, not the round-currency branch.

binding.round is 2 (line 340). setHostView supplies current_round: 2, so view.current_round !== binding.round is false. The pairing lookup in acceptMatchSettlement matches on match_id and candidate.round === binding.round, and the fixture supplies pairing("m-12", 1, 1, 2) with round 1. The lookup therefore returns undefined and the rejection comes from !pairing.

The view.current_round !== binding.round guard stays untested. Add a case that keeps the pairing at binding.round and advances current_round.

🧪 Proposed added case

+    it("rejects a bound settlement once the pod advanced past its round", async () => {
+      setHostView({
+        current_round: 3,
+        pairings: [pairing("m-12", 2, 1, 2)],
+      });
+      await deliverSettlement(1);
+      expect(reportSpy).not.toHaveBeenCalled();
+      expect(sent.get(1)).toEqual([
+        { type: "draft_error", reason: "Unauthorized match settlement" },
+      ]);
+    });

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@client/src/adapter/__tests__/p2pDraftHostBo3.test.ts` around lines 437 - 445,
Update the test around the settlement rejection case so the pairing returned by
pairing("m-12", ...) uses binding.round (2), while setHostView.current_round is
advanced to a different round (for example, 3). Keep the settlement delivery and
rejection assertions, ensuring acceptMatchSettlement exercises the
view.current_round !== binding.round guard rather than the !pairing branch.

client/src/network/protocol.ts-95-110 (1)

95-110: 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Reconcile the duplicated version-17 log entries.

The version log now has two separate 17 headings: line 95 for sacrificial-mana source selection, and line 103 for bound draft-match concession. The second one is also placed between the 7 and 6 entries, which breaks the descending order and hides it from a reader scanning the top of the list. WIRE_PROTOCOL_VERSION is a single integer, so both changes ship as one version and must be described in one entry.

This version also adds the authority stamp, sessionKey on reconnect, revision on game_setup/state_update/reconnect_ack, and the terminal_result frame. None of those appear in the log. A future author bumping to 18 can miss one of the two 17 blocks.

📝 Proposed consolidation

- *  17 — Sacrificial-mana source selection action and waiting-state snapshots.
+ *  17 — Sacrificial-mana source selection action and waiting-state snapshots;
+ *       host authority stamp on every host-originated frame; reconnect
+ *       sessionKey; state revisions on game_setup/state_update/reconnect_ack;
+ *       recipient-scoped terminal_result frames; bound draft-match concession
+ *       request (a Traditional-draft guest asks its match authority to settle
+ *       the match instead of sending a game-level concession).
  *  12 — Connive exact subject snapshots and resident paused post-replacement
  *       drains changed P2P GameState snapshots.
  *  11 — Serialized GameState trigger provenance and paused logical zone-change owners.
  *  10 — Dedicated companion deck slot and typed companion-reveal choices.
  *   9 — Meld pair and attacking-entry choices after mana-payment preview variants.
  *   8 — Mana-payment preview request/response variants.
  *   7 — PrecastCopyShortcut action and its two WaitingFor variants.
- *  17 — Bound draft-match concession request. A Traditional-draft guest
- *       asks its match authority to settle the match; it must not send a
- *       game-level concession through the ordinary P2P path.
  *   6 — Mulligan bottoming folded into a MulliganDecisionPhase::BottomCards

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@client/src/network/protocol.ts` around lines 95 - 110, Consolidate the
duplicate version-17 entries in the protocol version history comment into one
top-level entry, preserving descending order and covering all version-17
changes: sacrificial-mana source selection, bound draft-match concession,
authority stamping, reconnect sessionKey, revision fields, and the
terminal_result frame. Keep WIRE_PROTOCOL_VERSION unchanged at 17.

crates/engine/src/game/match_flow.rs-295-313 (1)

295-313: 🗄️ Data Integrity & Integration | 🟡 Minor | ⚡ Quick win

A forfeit by a player who already holds two game wins produces a 2-2 frozen score.

The guards accept any state whose match_phase is not Completed. If p0_wins is already 2 while the phase is still InGame — the window before handle_game_over_transition runs for the clinching game — and PlayerId(0) forfeits, Line 301 sets p1_wins = 2. The recorded match_score becomes 2-2 while match_forfeit_result.winner is PlayerId(1), and that inconsistent score is what terminal presentation freezes and shows.

Reject the forfeit when the opponent has already clinched the match, so the earned result is never overwritten.

🐛 Proposed fix

     let winner = match forfeiting_player {
         PlayerId(0) => PlayerId(1),
         PlayerId(1) => PlayerId(0),
         _ => return Err("Forfeiting player is not a match seat".to_string()),
     };
+    // A seat that has already won the match cannot hand it to its opponent:
+    // clamping the opponent to two wins would record a 2-2 score.
+    let forfeiting_wins = match forfeiting_player {
+        PlayerId(0) => state.match_score.p0_wins,
+        _ => state.match_score.p1_wins,
+    };
+    if forfeiting_wins >= 2 {
+        return Err("Forfeiting player has already won the match".to_string());
+    }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/engine/src/game/match_flow.rs` around lines 295 - 313, Update the
forfeit handling before the score mutation in the match transition flow to
reject a forfeit when the forfeiting player’s opponent already has the clinching
game count (two wins), even if match_phase is not yet Completed. Preserve the
existing score and winner state in that case, and only execute the
match_forfeit_result and frozen-score updates for valid forfeits.

crates/phase-server/src/persistence.rs-403-423 (1)

403-423: 🗄️ Data Integrity & Integration | 🟡 Minor | ⚡ Quick win

The activation upsert accepts an equal generation and can overwrite a live snapshot with revision 0.

The guard at Line 414 is excluded.generation >= game_sessions.generation. The earlier check at Line 391 only rejects a strictly greater stored generation. An activation for the same game_code and the same generation therefore passes both checks and replaces session_json and mutation_revision with the freshly created values, discarding the retained state of the row already at that generation.

create_full_session_key refuses to allocate while a non-retired row exists, so the path is not reachable today. Rated by effect when reached, this is snapshot loss for an active session. Make the predicate strict, and let the caller treat a non-Applied disposition as the conflict it is.

🐛 Proposed fix

-             WHERE excluded.generation >= game_sessions.generation",
+             WHERE excluded.generation > game_sessions.generation
+                OR game_sessions.retired = 1",

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/phase-server/src/persistence.rs` around lines 403 - 423, Update the
conflict predicate in the game-session activation upsert to require
excluded.generation to be strictly greater than game_sessions.generation,
preventing equal-generation snapshots from overwriting retained state. In the
surrounding activation caller, handle any disposition other than Applied as a
conflict, preserving existing behavior for successfully applied activations.

crates/engine/src/parser/oracle_tests.rs-23286-23320 (1)

23286-23320: 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Add the reach-guards this test's three siblings carry.

explicit_source_counter_gate_over_prior_target_stays_source_scoped asserts a scope value without proving the rider reached the code under test. Its siblings depletion_land_rider_sacrifice_binds_self_ref, typed_trigger_source_counter_rider_binds_self_ref_not_triggering_source, and source_counter_gate_over_prior_target_keeps_parent_not_self_ref all assert zero parse warnings and zero Effect::Unimplemented first.

Without those guards, a rider that misparsed into an Unimplemented effect while still carrying a CountersOn { scope: Source } condition satisfies the matches! and the test passes for the wrong reason. This test is the discriminating half of the pair with the Revelation of Power guard, so a false green here removes the only evidence that the suppression keys on the bare anaphor rather than on "a prior typed target exists".

💚 Proposed reach-guards and a positive rider-shape assertion

     );
 
+    assert!(
+        parsed.parse_warnings.is_empty(),
+        "expected zero parse warnings, got {:#?}",
+        parsed.parse_warnings
+    );
+    fn has_unimpl(def: &AbilityDefinition) -> bool {
+        matches!(def.effect.as_ref(), Effect::Unimplemented { .. })
+            || def.sub_ability.as_deref().is_some_and(has_unimpl)
+    }
+    assert!(
+        !parsed.abilities.iter().any(has_unimpl),
+        "no Unimplemented anywhere in the parse: {:#?}",
+        parsed.abilities
+    );
     let rider = parsed.abilities[0]
         .sub_ability
         .as_deref()
         .expect("conditional flying rider");
+    assert!(
+        matches!(rider.effect.as_ref(), Effect::GenericEffect { .. }),
+        "the rider must remain the flying grant, got {:?}",
+        rider.effect
+    );
     assert!(

As per path instructions: "For every negative assertion … require a paired positive reach-guard proving the input actually reached the code under test (parse succeeded, zero Effect::Unimplemented, expected positive shape); an upstream short-circuit makes a negative pass for the wrong reason."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/engine/src/parser/oracle_tests.rs` around lines 23286 - 23320, Update
explicit_source_counter_gate_over_prior_target_stays_source_scoped to add reach
guards before the scope match: assert zero parse warnings and zero
Effect::Unimplemented effects, then assert the rider’s expected positive shape
before checking CountersOn with ObjectScope::Source. Mirror the guard pattern
used by depletion_land_rider_sacrifice_binds_self_ref,
typed_trigger_source_counter_rider_binds_self_ref_not_triggering_source, and
source_counter_gate_over_prior_target_keeps_parent_not_self_ref.

Source: Path instructions

crates/engine/tests/integration/issue_4956_gift_of_immortality_reattach.rs-982-993 (1)

982-993: 🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Accepting Effect::Unimplemented makes this assertion non-discriminating.

The match arm at Line 987 passes when the leave-battlefield rider is completely unmodeled. The test then reports success for both the fixed shape (AddTargetReplacement{TrackedSet}) and the unfixed shape. Assert the intended shape only, or split the tolerance into a separate #[ignore]d or explicitly documented expected-gap test so a regression to Unimplemented fails.

As per path instructions: "Flag constructor shortcuts … that can silently mask the very bug a regression test claims to catch."

🧪 Proposed tightening

     match find_leave_rider(execute) {
         Some(Effect::AddTargetReplacement {
             target: TargetFilter::TrackedSet { .. },
             ..
         }) => {}
-        Some(Effect::Unimplemented { .. }) => {}
         Some(other) => panic!(
-            "leave-battlefield rider must be AddTargetReplacement{{TrackedSet}} or \
-             Unimplemented, got {other:?}"
+            "leave-battlefield rider must be AddTargetReplacement{{TrackedSet}}, got {other:?}"
         ),
         None => panic!("expected leave-battlefield rider in Storm Herald chain"),
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/engine/tests/integration/issue_4956_gift_of_immortality_reattach.rs`
around lines 982 - 993, Update the leave-battlefield rider assertion around
find_leave_rider so only Effect::AddTargetReplacement with
TargetFilter::TrackedSet is accepted. Remove the successful
Effect::Unimplemented match arm, ensuring an unmodeled rider reaches the
existing failure path and the regression test cannot pass for the unfixed
behavior.

Source: Path instructions

crates/engine/src/game/casting_tests.rs-31223-31317 (1)

31223-31317: 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Pair the three sibling-gate negatives with a positive reach-guard that uses add_bare_subtype_forest.

bare_subtype_land_detained_excluded_from_legal_mana_actions, bare_subtype_land_phased_out_excluded_from_legal_mana_actions, and bare_subtype_land_cant_tap_excluded_from_legal_mana_actions assert only absence from activatable_mana_actions_for_player. All three build their land through add_bare_subtype_forest. The positive companion bare_subtype_land_still_offers_mana_without_a_prohibition builds its land inline instead of calling that helper. If the helper ever stops producing a valid intrinsic mana source (for example a changed subtype string or a missing entered_battlefield_turn), all three negatives pass for the wrong reason and the positive test still passes.

Add a positive assertion inside each gate test before applying the gate, or route the positive companion through the same helper.

💚 Proposed reach-guard inside one gate test

     let mut state = setup_game_at_main_phase();
     let forest = add_bare_subtype_forest(&mut state, PlayerId(1), 0xF0128);
+    assert!(
+        crate::game::mana_sources::activatable_mana_actions_for_player(&state, PlayerId(1))
+            .iter()
+            .any(|action| action.source_object() == Some(forest)),
+        "reach-guard: the helper-built land must offer its intrinsic mana ability before the gate"
+    );
     state
         .objects
         .get_mut(&forest)

As per path instructions: "For every negative assertion (!detector(...), "not applied", "does not parse to X"), require a paired positive reach-guard proving the input actually reached the code under test".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/engine/src/game/casting_tests.rs` around lines 31223 - 31317, Ensure
the three negative tests using add_bare_subtype_forest first verify that the
unmodified forest appears in activatable_mana_actions_for_player, before
applying detention, phasing, or CantTap. Alternatively, update
bare_subtype_land_still_offers_mana_without_a_prohibition to construct the land
through add_bare_subtype_forest, so the shared helper is positively proven to
produce an intrinsic mana source before each prohibition assertion.

Source: Path instructions

crates/engine/src/parser/oracle_tests.rs (3)

23059-23062: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Extract the duplicated has_unimpl helper.

fn has_unimpl is defined identically three times in this file: at Line 23059, Line 23133, and Line 23222. Move it to a single module-level helper function and call it from each test.

♻️ Proposed refactor

+fn ability_has_unimpl(def: &AbilityDefinition) -> bool {
+    matches!(def.effect.as_ref(), Effect::Unimplemented { .. })
+        || def.sub_ability.as_deref().is_some_and(ability_has_unimpl)
+}
+
 #[test]
 fn depletion_land_rider_sacrifice_binds_self_ref() {
     ...
-    fn has_unimpl(def: &AbilityDefinition) -> bool {
-        matches!(def.effect.as_ref(), Effect::Unimplemented { .. })
-            || def.sub_ability.as_deref().is_some_and(has_unimpl)
-    }
     assert!(
-        !parsed.abilities.iter().any(has_unimpl),
+        !parsed.abilities.iter().any(ability_has_unimpl),
         "no Unimplemented anywhere in the parse: {:#?}",
         parsed.abilities
     );

Also applies to: 23133-23136, 23222-23225

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/engine/src/parser/oracle_tests.rs` around lines 23059 - 23062, Extract
the duplicated has_unimpl helper into one module-level function in
oracle_tests.rs, then remove the three local definitions and reuse the shared
helper from each affected test. Preserve its existing recursive check for
Effect::Unimplemented and nested sub_ability values.

---

23278-23315: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick win

Add reach-guards to this test, matching its siblings.

This test does not assert parsed.parse_warnings.is_empty() or check for Effect::Unimplemented before asserting the HasCounters shape, unlike depletion_land_rider_sacrifice_binds_self_ref (Line 23054-23067), typed_trigger_source_counter_rider_binds_self_ref_not_triggering_source (Line 23128-23145), and source_counter_gate_over_prior_target_keeps_parent_not_self_ref (Line 23217-23230). Without these guards, a degraded parse that still happens to produce a GenericEffect/HasCounters shape through a different, unintended path would pass this test for the wrong reason. This test protects the same anaphora-binding logic that a prior review already flagged as a regression source (Revelation of Power), so the same reach-guard rigor applies here.

✅ Proposed fix

     let rider = parsed.abilities[0]
         .sub_ability
         .as_deref()
         .expect("conditional flying rider");
+    assert!(
+        parsed.parse_warnings.is_empty(),
+        "expected zero parse warnings, got {:#?}",
+        parsed.parse_warnings
+    );
     let Effect::GenericEffect {
         static_abilities, ..
     } = rider.effect.as_ref()

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/engine/src/parser/oracle_tests.rs` around lines 23278 - 23315,
Strengthen explicit_source_counter_gate_over_prior_target_stays_source_scoped
with the same reach guards as its sibling tests: assert parsed.parse_warnings is
empty and verify the relevant parsed effect is not Effect::Unimplemented before
inspecting its GenericEffect/HasCounters structure. Keep the existing semantic
assertions unchanged.

---

23278-23281: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Fix the CR 608.2c citation.

The comment cites "CR 122.1 + CR 608.2c" to justify that a prior typed target does not rewrite an explicit source subject. CR 608.2c reads: "The controller of the spell or ability follows its instructions in the order written." That rule governs order-of-resolution, not anaphor/subject binding. Cite a rule that actually supports subject-scope preservation (for example, CR 608.2k already used correctly elsewhere in this file for anaphora to a cost/trigger-named object) instead of CR 608.2c here.

Based on learnings, cite "CR 608.2c only when the comment is documenting the resolution of written instructions “in order” (not for general keyword-list behavior)."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/engine/src/parser/oracle_tests.rs` around lines 23278 - 23281, Update
the test comment above the affected test to replace the incorrect CR 608.2c
citation with the applicable subject/anaphora-scope rule, such as CR 608.2k,
while retaining CR 122.1 if relevant. Use CR 608.2c only for comments describing
resolution of written instructions in order, not subject binding or keyword-list
behavior.

Source: Learnings

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes